A storage system typically comprises one or more storage devices in which information can be stored and from which information can be retrieved. A network storage system can be implemented in accordance with any of a variety of storage architectures and techniques including, but not limited to, a network-attached storage (NAS) environment or a storage area network (SAN).
A storage system typically includes a storage operating system that implements a high-level data organization module, sometimes called a file system, to logically organize stored data in hierarchical structures of logical containers. The logical containers can be or include, for example, volumes, files and/or logical units. A volume is a logical data set which is an abstraction of physical storage, combining one or more physical mass storage devices (e.g., disks) or parts thereof into a single logical storage object. Volumes can be further organized into aggregates. An aggregate is a logical container for a pool of storage, combining one or more physical mass storage devices (e.g., disks) or parts thereof into a single logical storage object, which contains or provides storage for one or more other logical data sets at a higher level of abstraction (e.g., volumes). Each logical container can be configured to store data in smaller units, often called blocks. Each block contains information, which may include the actual data of the file and/or metadata. The blocks of one or more files can be organized within one or more volumes that are maintained by the file system.
A network storage system can be configured to operate according to a client-server model of information delivery, to allow clients to store and access data in the system via a network. In this model, the client can have an application, such as a database application, executing in a computer that communicates with the storage system. Each client may send input/output (I/O) requests to read and write the data containers.
Two or more storage systems may be interconnected as nodes in a storage cluster to service client requests. Clustered storage systems can provide redundancy for the data stored in the systems, so that if one node becomes unavailable, then another node in the cluster takes over the storage space managed by the unavailable node to provide uninterrupted data service to the client. For example, a high-availability (HA) cluster can harness storage servers in pairs, groups or clusters to provide continued service when one or more of the system components fail. An HA cluster can detect hardware or software faults in one of its nodes and immediately cause another node to takeover the service from the at-fault node without requiring administrative intervention; this is a process known as failover.
In such an environment, managing access rights associated with input/output (I/O) operations (reads and writes) is a challenge. Access rights may be managed by issuing locks to one or more client applications (each of which can be referred to as “a client”), on a data container or a set of data residing at a storage volume. A lock provides certain rights to the entity (e.g. a client) which owns the lock, to perform read and write operations with respect to the data or the data container. The lock prevents the interceding update scenario in which more than one entity attempts to access the same data simultaneously. Continuous efforts are being made to better manage locks in networked storage systems without interrupting clients' data requests.
For example, nodes within a networked storage cluster can store information of the locks in a shared memory that multiple nodes can access. When a first node fails, a second node can takeover storage of the first node and retrieve information of the locks for the storage from the shared memory. Thus, the second node can continue to service data requests for the taken-over storage and maintain access rights of the taken-over storage controlled by the locks. However, shared memory architectures are costly and require special hardware to implement. When a client owns a lock as an exclusive right to read or write data, the client may cache I/O operations such as writes in a local cache first. Then the client may commit the cached operations to the data container in a batch for performance reasons. Events including takeover, giveback, and aggregate relocation are storage level events. There is no provision in protocol to communicate that information regarding the events to clients. For instance, when events such as takeover occur, the client may not receive the notification about the takeover and may continue to accumulate operations in the local cache.